﻿
namespace SilverErp.Web.DATA
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.ComponentModel.DataAnnotations;
    using System.Data;
    using System.Linq;
    using System.ServiceModel.DomainServices.EntityFramework;
    using System.ServiceModel.DomainServices.Hosting;
    using System.ServiceModel.DomainServices.Server;


    // Implements application logic using the ErpEntities context.
    // TODO: Add your application logic to these methods or in additional methods.
    // TODO: Wire up authentication (Windows/ASP.NET Forms) and uncomment the following to disable anonymous access
    // Also consider adding roles to restrict access as appropriate.
    // [RequiresAuthentication]
    [EnableClientAccess()]
    public class ErpService : LinqToEntitiesDomainService<ErpEntities>
    {

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'AnaMenu' query.
        public IQueryable<AnaMenu> GetAnaMenu()
        {
            return this.ObjectContext.AnaMenu;
        }

        public void InsertAnaMenu(AnaMenu anaMenu)
        {
            if ((anaMenu.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(anaMenu, EntityState.Added);
            }
            else
            {
                this.ObjectContext.AnaMenu.AddObject(anaMenu);
            }
        }

        public void UpdateAnaMenu(AnaMenu currentAnaMenu)
        {
            this.ObjectContext.AnaMenu.AttachAsModified(currentAnaMenu, this.ChangeSet.GetOriginal(currentAnaMenu));
        }

        public void DeleteAnaMenu(AnaMenu anaMenu)
        {
            if ((anaMenu.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(anaMenu, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.AnaMenu.Attach(anaMenu);
                this.ObjectContext.AnaMenu.DeleteObject(anaMenu);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'BankaHesaplari' query.
        public IQueryable<BankaHesaplari> GetBankaHesaplari()
        {
            return this.ObjectContext.BankaHesaplari;
        }

        public void InsertBankaHesaplari(BankaHesaplari bankaHesaplari)
        {
            if ((bankaHesaplari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(bankaHesaplari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.BankaHesaplari.AddObject(bankaHesaplari);
            }
        }

        public void UpdateBankaHesaplari(BankaHesaplari currentBankaHesaplari)
        {
            this.ObjectContext.BankaHesaplari.AttachAsModified(currentBankaHesaplari, this.ChangeSet.GetOriginal(currentBankaHesaplari));
        }

        public void DeleteBankaHesaplari(BankaHesaplari bankaHesaplari)
        {
            if ((bankaHesaplari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(bankaHesaplari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.BankaHesaplari.Attach(bankaHesaplari);
                this.ObjectContext.BankaHesaplari.DeleteObject(bankaHesaplari);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'BankaTanimlari' query.
        public IQueryable<BankaTanimlari> GetBankaTanimlari()
        {
            return this.ObjectContext.BankaTanimlari;
        }

        public void InsertBankaTanimlari(BankaTanimlari bankaTanimlari)
        {
            if ((bankaTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(bankaTanimlari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.BankaTanimlari.AddObject(bankaTanimlari);
            }
        }

        public void UpdateBankaTanimlari(BankaTanimlari currentBankaTanimlari)
        {
            this.ObjectContext.BankaTanimlari.AttachAsModified(currentBankaTanimlari, this.ChangeSet.GetOriginal(currentBankaTanimlari));
        }

        public void DeleteBankaTanimlari(BankaTanimlari bankaTanimlari)
        {
            if ((bankaTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(bankaTanimlari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.BankaTanimlari.Attach(bankaTanimlari);
                this.ObjectContext.BankaTanimlari.DeleteObject(bankaTanimlari);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'Barkodlar' query.
        public IQueryable<Barkodlar> GetBarkodlar()
        {
            return this.ObjectContext.Barkodlar;
        }

        public void InsertBarkodlar(Barkodlar barkodlar)
        {
            if ((barkodlar.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(barkodlar, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Barkodlar.AddObject(barkodlar);
            }
        }

        public void UpdateBarkodlar(Barkodlar currentBarkodlar)
        {
            this.ObjectContext.Barkodlar.AttachAsModified(currentBarkodlar, this.ChangeSet.GetOriginal(currentBarkodlar));
        }

        public void DeleteBarkodlar(Barkodlar barkodlar)
        {
            if ((barkodlar.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(barkodlar, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Barkodlar.Attach(barkodlar);
                this.ObjectContext.Barkodlar.DeleteObject(barkodlar);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'BedenTanimlari' query.
        public IQueryable<BedenTanimlari> GetBedenTanimlari()
        {
            return this.ObjectContext.BedenTanimlari;
        }

        public void InsertBedenTanimlari(BedenTanimlari bedenTanimlari)
        {
            if ((bedenTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(bedenTanimlari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.BedenTanimlari.AddObject(bedenTanimlari);
            }
        }

        public void UpdateBedenTanimlari(BedenTanimlari currentBedenTanimlari)
        {
            this.ObjectContext.BedenTanimlari.AttachAsModified(currentBedenTanimlari, this.ChangeSet.GetOriginal(currentBedenTanimlari));
        }

        public void DeleteBedenTanimlari(BedenTanimlari bedenTanimlari)
        {
            if ((bedenTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(bedenTanimlari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.BedenTanimlari.Attach(bedenTanimlari);
                this.ObjectContext.BedenTanimlari.DeleteObject(bedenTanimlari);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'Birimler' query.
        public IQueryable<Birimler> GetBirimler()
        {
            return this.ObjectContext.Birimler;
        }

        public void InsertBirimler(Birimler birimler)
        {
            if ((birimler.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(birimler, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Birimler.AddObject(birimler);
            }
        }

        public void UpdateBirimler(Birimler currentBirimler)
        {
            this.ObjectContext.Birimler.AttachAsModified(currentBirimler, this.ChangeSet.GetOriginal(currentBirimler));
        }

        public void DeleteBirimler(Birimler birimler)
        {
            if ((birimler.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(birimler, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Birimler.Attach(birimler);
                this.ObjectContext.Birimler.DeleteObject(birimler);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'CariAdresleri' query.
        public IQueryable<CariAdresleri> GetCariAdresleri()
        {
            return this.ObjectContext.CariAdresleri;
        }

        public void InsertCariAdresleri(CariAdresleri cariAdresleri)
        {
            if ((cariAdresleri.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(cariAdresleri, EntityState.Added);
            }
            else
            {
                this.ObjectContext.CariAdresleri.AddObject(cariAdresleri);
            }
        }

        public void UpdateCariAdresleri(CariAdresleri currentCariAdresleri)
        {
            this.ObjectContext.CariAdresleri.AttachAsModified(currentCariAdresleri, this.ChangeSet.GetOriginal(currentCariAdresleri));
        }

        public void DeleteCariAdresleri(CariAdresleri cariAdresleri)
        {
            if ((cariAdresleri.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(cariAdresleri, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.CariAdresleri.Attach(cariAdresleri);
                this.ObjectContext.CariAdresleri.DeleteObject(cariAdresleri);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'Cariler' query.
        public IQueryable<Cariler> GetCariler()
        {
            return this.ObjectContext.Cariler;
        }

        public void InsertCariler(Cariler cariler)
        {
            if ((cariler.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(cariler, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Cariler.AddObject(cariler);
            }
        }

        public void UpdateCariler(Cariler currentCariler)
        {
            this.ObjectContext.Cariler.AttachAsModified(currentCariler, this.ChangeSet.GetOriginal(currentCariler));
        }

        public void DeleteCariler(Cariler cariler)
        {
            if ((cariler.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(cariler, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Cariler.Attach(cariler);
                this.ObjectContext.Cariler.DeleteObject(cariler);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'CariOzellikleri' query.
        public IQueryable<CariOzellikleri> GetCariOzellikleri()
        {
            return this.ObjectContext.CariOzellikleri;
        }

        public void InsertCariOzellikleri(CariOzellikleri cariOzellikleri)
        {
            if ((cariOzellikleri.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(cariOzellikleri, EntityState.Added);
            }
            else
            {
                this.ObjectContext.CariOzellikleri.AddObject(cariOzellikleri);
            }
        }

        public void UpdateCariOzellikleri(CariOzellikleri currentCariOzellikleri)
        {
            this.ObjectContext.CariOzellikleri.AttachAsModified(currentCariOzellikleri, this.ChangeSet.GetOriginal(currentCariOzellikleri));
        }

        public void DeleteCariOzellikleri(CariOzellikleri cariOzellikleri)
        {
            if ((cariOzellikleri.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(cariOzellikleri, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.CariOzellikleri.Attach(cariOzellikleri);
                this.ObjectContext.CariOzellikleri.DeleteObject(cariOzellikleri);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'DegerliKagitHareketleri' query.
        public IQueryable<DegerliKagitHareketleri> GetDegerliKagitHareketleri()
        {
            return this.ObjectContext.DegerliKagitHareketleri;
        }

        public void InsertDegerliKagitHareketleri(DegerliKagitHareketleri degerliKagitHareketleri)
        {
            if ((degerliKagitHareketleri.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(degerliKagitHareketleri, EntityState.Added);
            }
            else
            {
                this.ObjectContext.DegerliKagitHareketleri.AddObject(degerliKagitHareketleri);
            }
        }

        public void UpdateDegerliKagitHareketleri(DegerliKagitHareketleri currentDegerliKagitHareketleri)
        {
            this.ObjectContext.DegerliKagitHareketleri.AttachAsModified(currentDegerliKagitHareketleri, this.ChangeSet.GetOriginal(currentDegerliKagitHareketleri));
        }

        public void DeleteDegerliKagitHareketleri(DegerliKagitHareketleri degerliKagitHareketleri)
        {
            if ((degerliKagitHareketleri.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(degerliKagitHareketleri, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.DegerliKagitHareketleri.Attach(degerliKagitHareketleri);
                this.ObjectContext.DegerliKagitHareketleri.DeleteObject(degerliKagitHareketleri);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'DegerliKagitlar' query.
        public IQueryable<DegerliKagitlar> GetDegerliKagitlar()
        {
            return this.ObjectContext.DegerliKagitlar;
        }

        public void InsertDegerliKagitlar(DegerliKagitlar degerliKagitlar)
        {
            if ((degerliKagitlar.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(degerliKagitlar, EntityState.Added);
            }
            else
            {
                this.ObjectContext.DegerliKagitlar.AddObject(degerliKagitlar);
            }
        }

        public void UpdateDegerliKagitlar(DegerliKagitlar currentDegerliKagitlar)
        {
            this.ObjectContext.DegerliKagitlar.AttachAsModified(currentDegerliKagitlar, this.ChangeSet.GetOriginal(currentDegerliKagitlar));
        }

        public void DeleteDegerliKagitlar(DegerliKagitlar degerliKagitlar)
        {
            if ((degerliKagitlar.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(degerliKagitlar, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.DegerliKagitlar.Attach(degerliKagitlar);
                this.ObjectContext.DegerliKagitlar.DeleteObject(degerliKagitlar);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'Depolar' query.
        public IQueryable<Depolar> GetDepolar()
        {
            return this.ObjectContext.Depolar;
        }

        public void InsertDepolar(Depolar depolar)
        {
            if ((depolar.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(depolar, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Depolar.AddObject(depolar);
            }
        }

        public void UpdateDepolar(Depolar currentDepolar)
        {
            this.ObjectContext.Depolar.AttachAsModified(currentDepolar, this.ChangeSet.GetOriginal(currentDepolar));
        }

        public void DeleteDepolar(Depolar depolar)
        {
            if ((depolar.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(depolar, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Depolar.Attach(depolar);
                this.ObjectContext.Depolar.DeleteObject(depolar);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'Donemler' query.
        public IQueryable<Donemler> GetDonemler()
        {
            return this.ObjectContext.Donemler;
        }

        public void InsertDonemler(Donemler donemler)
        {
            if ((donemler.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(donemler, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Donemler.AddObject(donemler);
            }
        }

        public void UpdateDonemler(Donemler currentDonemler)
        {
            this.ObjectContext.Donemler.AttachAsModified(currentDonemler, this.ChangeSet.GetOriginal(currentDonemler));
        }

        public void DeleteDonemler(Donemler donemler)
        {
            if ((donemler.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(donemler, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Donemler.Attach(donemler);
                this.ObjectContext.Donemler.DeleteObject(donemler);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'DovizKurlari' query.
        public IQueryable<DovizKurlari> GetDovizKurlari()
        {
            return this.ObjectContext.DovizKurlari;
        }

        public void InsertDovizKurlari(DovizKurlari dovizKurlari)
        {
            if ((dovizKurlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(dovizKurlari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.DovizKurlari.AddObject(dovizKurlari);
            }
        }

        public void UpdateDovizKurlari(DovizKurlari currentDovizKurlari)
        {
            this.ObjectContext.DovizKurlari.AttachAsModified(currentDovizKurlari, this.ChangeSet.GetOriginal(currentDovizKurlari));
        }

        public void DeleteDovizKurlari(DovizKurlari dovizKurlari)
        {
            if ((dovizKurlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(dovizKurlari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.DovizKurlari.Attach(dovizKurlari);
                this.ObjectContext.DovizKurlari.DeleteObject(dovizKurlari);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'DovizTanimlari' query.
        public IQueryable<DovizTanimlari> GetDovizTanimlari()
        {
            return this.ObjectContext.DovizTanimlari;
        }

        public void InsertDovizTanimlari(DovizTanimlari dovizTanimlari)
        {
            if ((dovizTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(dovizTanimlari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.DovizTanimlari.AddObject(dovizTanimlari);
            }
        }

        public void UpdateDovizTanimlari(DovizTanimlari currentDovizTanimlari)
        {
            this.ObjectContext.DovizTanimlari.AttachAsModified(currentDovizTanimlari, this.ChangeSet.GetOriginal(currentDovizTanimlari));
        }

        public void DeleteDovizTanimlari(DovizTanimlari dovizTanimlari)
        {
            if ((dovizTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(dovizTanimlari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.DovizTanimlari.Attach(dovizTanimlari);
                this.ObjectContext.DovizTanimlari.DeleteObject(dovizTanimlari);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'EtiketTanimlari' query.
        public IQueryable<EtiketTanimlari> GetEtiketTanimlari()
        {
            return this.ObjectContext.EtiketTanimlari;
        }

        public void InsertEtiketTanimlari(EtiketTanimlari etiketTanimlari)
        {
            if ((etiketTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(etiketTanimlari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.EtiketTanimlari.AddObject(etiketTanimlari);
            }
        }

        public void UpdateEtiketTanimlari(EtiketTanimlari currentEtiketTanimlari)
        {
            this.ObjectContext.EtiketTanimlari.AttachAsModified(currentEtiketTanimlari, this.ChangeSet.GetOriginal(currentEtiketTanimlari));
        }

        public void DeleteEtiketTanimlari(EtiketTanimlari etiketTanimlari)
        {
            if ((etiketTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(etiketTanimlari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.EtiketTanimlari.Attach(etiketTanimlari);
                this.ObjectContext.EtiketTanimlari.DeleteObject(etiketTanimlari);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'Evraklar' query.
        public IQueryable<Evraklar> GetEvraklar()
        {
            return this.ObjectContext.Evraklar;
        }

        public void InsertEvraklar(Evraklar evraklar)
        {
            if ((evraklar.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(evraklar, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Evraklar.AddObject(evraklar);
            }
        }

        public void UpdateEvraklar(Evraklar currentEvraklar)
        {
            this.ObjectContext.Evraklar.AttachAsModified(currentEvraklar, this.ChangeSet.GetOriginal(currentEvraklar));
        }

        public void DeleteEvraklar(Evraklar evraklar)
        {
            if ((evraklar.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(evraklar, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Evraklar.Attach(evraklar);
                this.ObjectContext.Evraklar.DeleteObject(evraklar);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'Firmalar' query.
        public IQueryable<Firmalar> GetFirmalar()
        {
            return this.ObjectContext.Firmalar;
        }

        public void InsertFirmalar(Firmalar firmalar)
        {
            if ((firmalar.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(firmalar, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Firmalar.AddObject(firmalar);
            }
        }

        public void UpdateFirmalar(Firmalar currentFirmalar)
        {
            this.ObjectContext.Firmalar.AttachAsModified(currentFirmalar, this.ChangeSet.GetOriginal(currentFirmalar));
        }

        public void DeleteFirmalar(Firmalar firmalar)
        {
            if ((firmalar.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(firmalar, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Firmalar.Attach(firmalar);
                this.ObjectContext.Firmalar.DeleteObject(firmalar);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'FiyatTanimlari' query.
        public IQueryable<FiyatTanimlari> GetFiyatTanimlari()
        {
            return this.ObjectContext.FiyatTanimlari;
        }

        public void InsertFiyatTanimlari(FiyatTanimlari fiyatTanimlari)
        {
            if ((fiyatTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(fiyatTanimlari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.FiyatTanimlari.AddObject(fiyatTanimlari);
            }
        }

        public void UpdateFiyatTanimlari(FiyatTanimlari currentFiyatTanimlari)
        {
            this.ObjectContext.FiyatTanimlari.AttachAsModified(currentFiyatTanimlari, this.ChangeSet.GetOriginal(currentFiyatTanimlari));
        }

        public void DeleteFiyatTanimlari(FiyatTanimlari fiyatTanimlari)
        {
            if ((fiyatTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(fiyatTanimlari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.FiyatTanimlari.Attach(fiyatTanimlari);
                this.ObjectContext.FiyatTanimlari.DeleteObject(fiyatTanimlari);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'Kasalar' query.
        public IQueryable<Kasalar> GetKasalar()
        {
            return this.ObjectContext.Kasalar;
        }

        public void InsertKasalar(Kasalar kasalar)
        {
            if ((kasalar.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(kasalar, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Kasalar.AddObject(kasalar);
            }
        }

        public void UpdateKasalar(Kasalar currentKasalar)
        {
            this.ObjectContext.Kasalar.AttachAsModified(currentKasalar, this.ChangeSet.GetOriginal(currentKasalar));
        }

        public void DeleteKasalar(Kasalar kasalar)
        {
            if ((kasalar.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(kasalar, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Kasalar.Attach(kasalar);
                this.ObjectContext.Kasalar.DeleteObject(kasalar);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'KullaniciMenu' query.
        public IQueryable<KullaniciMenu> GetKullaniciMenu()
        {
            return this.ObjectContext.KullaniciMenu;
        }

        public void InsertKullaniciMenu(KullaniciMenu kullaniciMenu)
        {
            if ((kullaniciMenu.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(kullaniciMenu, EntityState.Added);
            }
            else
            {
                this.ObjectContext.KullaniciMenu.AddObject(kullaniciMenu);
            }
        }

        public void UpdateKullaniciMenu(KullaniciMenu currentKullaniciMenu)
        {
            this.ObjectContext.KullaniciMenu.AttachAsModified(currentKullaniciMenu, this.ChangeSet.GetOriginal(currentKullaniciMenu));
        }

        public void DeleteKullaniciMenu(KullaniciMenu kullaniciMenu)
        {
            if ((kullaniciMenu.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(kullaniciMenu, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.KullaniciMenu.Attach(kullaniciMenu);
                this.ObjectContext.KullaniciMenu.DeleteObject(kullaniciMenu);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'KullaniciTanimlari' query.
        public IQueryable<KullaniciTanimlari> GetKullaniciTanimlari()
        {
            return this.ObjectContext.KullaniciTanimlari;
        }

        public void InsertKullaniciTanimlari(KullaniciTanimlari kullaniciTanimlari)
        {
            if ((kullaniciTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(kullaniciTanimlari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.KullaniciTanimlari.AddObject(kullaniciTanimlari);
            }
        }

        public void UpdateKullaniciTanimlari(KullaniciTanimlari currentKullaniciTanimlari)
        {
            this.ObjectContext.KullaniciTanimlari.AttachAsModified(currentKullaniciTanimlari, this.ChangeSet.GetOriginal(currentKullaniciTanimlari));
        }

        public void DeleteKullaniciTanimlari(KullaniciTanimlari kullaniciTanimlari)
        {
            if ((kullaniciTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(kullaniciTanimlari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.KullaniciTanimlari.Attach(kullaniciTanimlari);
                this.ObjectContext.KullaniciTanimlari.DeleteObject(kullaniciTanimlari);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'MasrafHizmetTanimlari' query.
        public IQueryable<MasrafHizmetTanimlari> GetMasrafHizmetTanimlari()
        {
            return this.ObjectContext.MasrafHizmetTanimlari;
        }

        public void InsertMasrafHizmetTanimlari(MasrafHizmetTanimlari masrafHizmetTanimlari)
        {
            if ((masrafHizmetTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(masrafHizmetTanimlari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.MasrafHizmetTanimlari.AddObject(masrafHizmetTanimlari);
            }
        }

        public void UpdateMasrafHizmetTanimlari(MasrafHizmetTanimlari currentMasrafHizmetTanimlari)
        {
            this.ObjectContext.MasrafHizmetTanimlari.AttachAsModified(currentMasrafHizmetTanimlari, this.ChangeSet.GetOriginal(currentMasrafHizmetTanimlari));
        }

        public void DeleteMasrafHizmetTanimlari(MasrafHizmetTanimlari masrafHizmetTanimlari)
        {
            if ((masrafHizmetTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(masrafHizmetTanimlari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.MasrafHizmetTanimlari.Attach(masrafHizmetTanimlari);
                this.ObjectContext.MasrafHizmetTanimlari.DeleteObject(masrafHizmetTanimlari);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'MuhasebeGruplari' query.
        public IQueryable<MuhasebeGruplari> GetMuhasebeGruplari()
        {
            return this.ObjectContext.MuhasebeGruplari;
        }

        public void InsertMuhasebeGruplari(MuhasebeGruplari muhasebeGruplari)
        {
            if ((muhasebeGruplari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(muhasebeGruplari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.MuhasebeGruplari.AddObject(muhasebeGruplari);
            }
        }

        public void UpdateMuhasebeGruplari(MuhasebeGruplari currentMuhasebeGruplari)
        {
            this.ObjectContext.MuhasebeGruplari.AttachAsModified(currentMuhasebeGruplari, this.ChangeSet.GetOriginal(currentMuhasebeGruplari));
        }

        public void DeleteMuhasebeGruplari(MuhasebeGruplari muhasebeGruplari)
        {
            if ((muhasebeGruplari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(muhasebeGruplari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.MuhasebeGruplari.Attach(muhasebeGruplari);
                this.ObjectContext.MuhasebeGruplari.DeleteObject(muhasebeGruplari);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'MuhasebeHesapPlani' query.
        public IQueryable<MuhasebeHesapPlani> GetMuhasebeHesapPlani()
        {
            return this.ObjectContext.MuhasebeHesapPlani;
        }

        public void InsertMuhasebeHesapPlani(MuhasebeHesapPlani muhasebeHesapPlani)
        {
            if ((muhasebeHesapPlani.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(muhasebeHesapPlani, EntityState.Added);
            }
            else
            {
                this.ObjectContext.MuhasebeHesapPlani.AddObject(muhasebeHesapPlani);
            }
        }

        public void UpdateMuhasebeHesapPlani(MuhasebeHesapPlani currentMuhasebeHesapPlani)
        {
            this.ObjectContext.MuhasebeHesapPlani.AttachAsModified(currentMuhasebeHesapPlani, this.ChangeSet.GetOriginal(currentMuhasebeHesapPlani));
        }

        public void DeleteMuhasebeHesapPlani(MuhasebeHesapPlani muhasebeHesapPlani)
        {
            if ((muhasebeHesapPlani.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(muhasebeHesapPlani, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.MuhasebeHesapPlani.Attach(muhasebeHesapPlani);
                this.ObjectContext.MuhasebeHesapPlani.DeleteObject(muhasebeHesapPlani);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'OzellikTanimlari' query.
        public IQueryable<OzellikTanimlari> GetOzellikTanimlari()
        {
            return this.ObjectContext.OzellikTanimlari;
        }

        public void InsertOzellikTanimlari(OzellikTanimlari ozellikTanimlari)
        {
            if ((ozellikTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(ozellikTanimlari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.OzellikTanimlari.AddObject(ozellikTanimlari);
            }
        }

        public void UpdateOzellikTanimlari(OzellikTanimlari currentOzellikTanimlari)
        {
            this.ObjectContext.OzellikTanimlari.AttachAsModified(currentOzellikTanimlari, this.ChangeSet.GetOriginal(currentOzellikTanimlari));
        }

        public void DeleteOzellikTanimlari(OzellikTanimlari ozellikTanimlari)
        {
            if ((ozellikTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(ozellikTanimlari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.OzellikTanimlari.Attach(ozellikTanimlari);
                this.ObjectContext.OzellikTanimlari.DeleteObject(ozellikTanimlari);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'PersonelTanimlari' query.
        public IQueryable<PersonelTanimlari> GetPersonelTanimlari()
        {
            return this.ObjectContext.PersonelTanimlari;
        }

        public void InsertPersonelTanimlari(PersonelTanimlari personelTanimlari)
        {
            if ((personelTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(personelTanimlari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.PersonelTanimlari.AddObject(personelTanimlari);
            }
        }

        public void UpdatePersonelTanimlari(PersonelTanimlari currentPersonelTanimlari)
        {
            this.ObjectContext.PersonelTanimlari.AttachAsModified(currentPersonelTanimlari, this.ChangeSet.GetOriginal(currentPersonelTanimlari));
        }

        public void DeletePersonelTanimlari(PersonelTanimlari personelTanimlari)
        {
            if ((personelTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(personelTanimlari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.PersonelTanimlari.Attach(personelTanimlari);
                this.ObjectContext.PersonelTanimlari.DeleteObject(personelTanimlari);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'RenkBedenGrubu' query.
        public IQueryable<RenkBedenGrubu> GetRenkBedenGrubu()
        {
            return this.ObjectContext.RenkBedenGrubu;
        }

        public void InsertRenkBedenGrubu(RenkBedenGrubu renkBedenGrubu)
        {
            if ((renkBedenGrubu.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(renkBedenGrubu, EntityState.Added);
            }
            else
            {
                this.ObjectContext.RenkBedenGrubu.AddObject(renkBedenGrubu);
            }
        }

        public void UpdateRenkBedenGrubu(RenkBedenGrubu currentRenkBedenGrubu)
        {
            this.ObjectContext.RenkBedenGrubu.AttachAsModified(currentRenkBedenGrubu, this.ChangeSet.GetOriginal(currentRenkBedenGrubu));
        }

        public void DeleteRenkBedenGrubu(RenkBedenGrubu renkBedenGrubu)
        {
            if ((renkBedenGrubu.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(renkBedenGrubu, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.RenkBedenGrubu.Attach(renkBedenGrubu);
                this.ObjectContext.RenkBedenGrubu.DeleteObject(renkBedenGrubu);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'RenkTanimlari' query.
        public IQueryable<RenkTanimlari> GetRenkTanimlari()
        {
            return this.ObjectContext.RenkTanimlari;
        }

        public void InsertRenkTanimlari(RenkTanimlari renkTanimlari)
        {
            if ((renkTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(renkTanimlari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.RenkTanimlari.AddObject(renkTanimlari);
            }
        }

        public void UpdateRenkTanimlari(RenkTanimlari currentRenkTanimlari)
        {
            this.ObjectContext.RenkTanimlari.AttachAsModified(currentRenkTanimlari, this.ChangeSet.GetOriginal(currentRenkTanimlari));
        }

        public void DeleteRenkTanimlari(RenkTanimlari renkTanimlari)
        {
            if ((renkTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(renkTanimlari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.RenkTanimlari.Attach(renkTanimlari);
                this.ObjectContext.RenkTanimlari.DeleteObject(renkTanimlari);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'StokDepoDetaylari' query.
        public IQueryable<StokDepoDetaylari> GetStokDepoDetaylari()
        {
            return this.ObjectContext.StokDepoDetaylari;
        }

        public void InsertStokDepoDetaylari(StokDepoDetaylari stokDepoDetaylari)
        {
            if ((stokDepoDetaylari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokDepoDetaylari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.StokDepoDetaylari.AddObject(stokDepoDetaylari);
            }
        }

        public void UpdateStokDepoDetaylari(StokDepoDetaylari currentStokDepoDetaylari)
        {
            this.ObjectContext.StokDepoDetaylari.AttachAsModified(currentStokDepoDetaylari, this.ChangeSet.GetOriginal(currentStokDepoDetaylari));
        }

        public void DeleteStokDepoDetaylari(StokDepoDetaylari stokDepoDetaylari)
        {
            if ((stokDepoDetaylari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokDepoDetaylari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.StokDepoDetaylari.Attach(stokDepoDetaylari);
                this.ObjectContext.StokDepoDetaylari.DeleteObject(stokDepoDetaylari);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'StokDonemOzeti' query.
        public IQueryable<StokDonemOzeti> GetStokDonemOzeti()
        {
            return this.ObjectContext.StokDonemOzeti;
        }

        public void InsertStokDonemOzeti(StokDonemOzeti stokDonemOzeti)
        {
            if ((stokDonemOzeti.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokDonemOzeti, EntityState.Added);
            }
            else
            {
                this.ObjectContext.StokDonemOzeti.AddObject(stokDonemOzeti);
            }
        }

        public void UpdateStokDonemOzeti(StokDonemOzeti currentStokDonemOzeti)
        {
            this.ObjectContext.StokDonemOzeti.AttachAsModified(currentStokDonemOzeti, this.ChangeSet.GetOriginal(currentStokDonemOzeti));
        }

        public void DeleteStokDonemOzeti(StokDonemOzeti stokDonemOzeti)
        {
            if ((stokDonemOzeti.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokDonemOzeti, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.StokDonemOzeti.Attach(stokDonemOzeti);
                this.ObjectContext.StokDonemOzeti.DeleteObject(stokDonemOzeti);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'StokEnvanterOzeti' query.
        public IQueryable<StokEnvanterOzeti> GetStokEnvanterOzeti()
        {
            return this.ObjectContext.StokEnvanterOzeti;
        }

        public void InsertStokEnvanterOzeti(StokEnvanterOzeti stokEnvanterOzeti)
        {
            if ((stokEnvanterOzeti.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokEnvanterOzeti, EntityState.Added);
            }
            else
            {
                this.ObjectContext.StokEnvanterOzeti.AddObject(stokEnvanterOzeti);
            }
        }

        public void UpdateStokEnvanterOzeti(StokEnvanterOzeti currentStokEnvanterOzeti)
        {
            this.ObjectContext.StokEnvanterOzeti.AttachAsModified(currentStokEnvanterOzeti, this.ChangeSet.GetOriginal(currentStokEnvanterOzeti));
        }

        public void DeleteStokEnvanterOzeti(StokEnvanterOzeti stokEnvanterOzeti)
        {
            if ((stokEnvanterOzeti.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokEnvanterOzeti, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.StokEnvanterOzeti.Attach(stokEnvanterOzeti);
                this.ObjectContext.StokEnvanterOzeti.DeleteObject(stokEnvanterOzeti);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'StokFiyatHareketleri' query.
        public IQueryable<StokFiyatHareketleri> GetStokFiyatHareketleri()
        {
            return this.ObjectContext.StokFiyatHareketleri;
        }

        public void InsertStokFiyatHareketleri(StokFiyatHareketleri stokFiyatHareketleri)
        {
            if ((stokFiyatHareketleri.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokFiyatHareketleri, EntityState.Added);
            }
            else
            {
                this.ObjectContext.StokFiyatHareketleri.AddObject(stokFiyatHareketleri);
            }
        }

        public void UpdateStokFiyatHareketleri(StokFiyatHareketleri currentStokFiyatHareketleri)
        {
            this.ObjectContext.StokFiyatHareketleri.AttachAsModified(currentStokFiyatHareketleri, this.ChangeSet.GetOriginal(currentStokFiyatHareketleri));
        }

        public void DeleteStokFiyatHareketleri(StokFiyatHareketleri stokFiyatHareketleri)
        {
            if ((stokFiyatHareketleri.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokFiyatHareketleri, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.StokFiyatHareketleri.Attach(stokFiyatHareketleri);
                this.ObjectContext.StokFiyatHareketleri.DeleteObject(stokFiyatHareketleri);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'StokFiyatlari' query.
        public IQueryable<StokFiyatlari> GetStokFiyatlari()
        {
            return this.ObjectContext.StokFiyatlari;
        }

        public void InsertStokFiyatlari(StokFiyatlari stokFiyatlari)
        {
            if ((stokFiyatlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokFiyatlari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.StokFiyatlari.AddObject(stokFiyatlari);
            }
        }

        public void UpdateStokFiyatlari(StokFiyatlari currentStokFiyatlari)
        {
            this.ObjectContext.StokFiyatlari.AttachAsModified(currentStokFiyatlari, this.ChangeSet.GetOriginal(currentStokFiyatlari));
        }

        public void DeleteStokFiyatlari(StokFiyatlari stokFiyatlari)
        {
            if ((stokFiyatlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokFiyatlari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.StokFiyatlari.Attach(stokFiyatlari);
                this.ObjectContext.StokFiyatlari.DeleteObject(stokFiyatlari);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'StokHareketleri' query.
        public IQueryable<StokHareketleri> GetStokHareketleri()
        {
            return this.ObjectContext.StokHareketleri;
        }

        public void InsertStokHareketleri(StokHareketleri stokHareketleri)
        {
            if ((stokHareketleri.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokHareketleri, EntityState.Added);
            }
            else
            {
                this.ObjectContext.StokHareketleri.AddObject(stokHareketleri);
            }
        }

        public void UpdateStokHareketleri(StokHareketleri currentStokHareketleri)
        {
            this.ObjectContext.StokHareketleri.AttachAsModified(currentStokHareketleri, this.ChangeSet.GetOriginal(currentStokHareketleri));
        }

        public void DeleteStokHareketleri(StokHareketleri stokHareketleri)
        {
            if ((stokHareketleri.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokHareketleri, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.StokHareketleri.Attach(stokHareketleri);
                this.ObjectContext.StokHareketleri.DeleteObject(stokHareketleri);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'Stoklar' query.
        public IQueryable<Stoklar> GetStoklar()
        {
            return this.ObjectContext.Stoklar;
        }

        public void InsertStoklar(Stoklar stoklar)
        {
            if ((stoklar.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stoklar, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Stoklar.AddObject(stoklar);
            }
        }

        public void UpdateStoklar(Stoklar currentStoklar)
        {
            this.ObjectContext.Stoklar.AttachAsModified(currentStoklar, this.ChangeSet.GetOriginal(currentStoklar));
        }

        public void DeleteStoklar(Stoklar stoklar)
        {
            if ((stoklar.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stoklar, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Stoklar.Attach(stoklar);
                this.ObjectContext.Stoklar.DeleteObject(stoklar);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'StokMaliyetOzeti' query.
        public IQueryable<StokMaliyetOzeti> GetStokMaliyetOzeti()
        {
            return this.ObjectContext.StokMaliyetOzeti;
        }

        public void InsertStokMaliyetOzeti(StokMaliyetOzeti stokMaliyetOzeti)
        {
            if ((stokMaliyetOzeti.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokMaliyetOzeti, EntityState.Added);
            }
            else
            {
                this.ObjectContext.StokMaliyetOzeti.AddObject(stokMaliyetOzeti);
            }
        }

        public void UpdateStokMaliyetOzeti(StokMaliyetOzeti currentStokMaliyetOzeti)
        {
            this.ObjectContext.StokMaliyetOzeti.AttachAsModified(currentStokMaliyetOzeti, this.ChangeSet.GetOriginal(currentStokMaliyetOzeti));
        }

        public void DeleteStokMaliyetOzeti(StokMaliyetOzeti stokMaliyetOzeti)
        {
            if ((stokMaliyetOzeti.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokMaliyetOzeti, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.StokMaliyetOzeti.Attach(stokMaliyetOzeti);
                this.ObjectContext.StokMaliyetOzeti.DeleteObject(stokMaliyetOzeti);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'StokMuadilRakipTanimlari' query.
        public IQueryable<StokMuadilRakipTanimlari> GetStokMuadilRakipTanimlari()
        {
            return this.ObjectContext.StokMuadilRakipTanimlari;
        }

        public void InsertStokMuadilRakipTanimlari(StokMuadilRakipTanimlari stokMuadilRakipTanimlari)
        {
            if ((stokMuadilRakipTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokMuadilRakipTanimlari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.StokMuadilRakipTanimlari.AddObject(stokMuadilRakipTanimlari);
            }
        }

        public void UpdateStokMuadilRakipTanimlari(StokMuadilRakipTanimlari currentStokMuadilRakipTanimlari)
        {
            this.ObjectContext.StokMuadilRakipTanimlari.AttachAsModified(currentStokMuadilRakipTanimlari, this.ChangeSet.GetOriginal(currentStokMuadilRakipTanimlari));
        }

        public void DeleteStokMuadilRakipTanimlari(StokMuadilRakipTanimlari stokMuadilRakipTanimlari)
        {
            if ((stokMuadilRakipTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokMuadilRakipTanimlari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.StokMuadilRakipTanimlari.Attach(stokMuadilRakipTanimlari);
                this.ObjectContext.StokMuadilRakipTanimlari.DeleteObject(stokMuadilRakipTanimlari);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'StokOzellikleri' query.
        public IQueryable<StokOzellikleri> GetStokOzellikleri()
        {
            return this.ObjectContext.StokOzellikleri;
        }

        public void InsertStokOzellikleri(StokOzellikleri stokOzellikleri)
        {
            if ((stokOzellikleri.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokOzellikleri, EntityState.Added);
            }
            else
            {
                this.ObjectContext.StokOzellikleri.AddObject(stokOzellikleri);
            }
        }

        public void UpdateStokOzellikleri(StokOzellikleri currentStokOzellikleri)
        {
            this.ObjectContext.StokOzellikleri.AttachAsModified(currentStokOzellikleri, this.ChangeSet.GetOriginal(currentStokOzellikleri));
        }

        public void DeleteStokOzellikleri(StokOzellikleri stokOzellikleri)
        {
            if ((stokOzellikleri.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokOzellikleri, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.StokOzellikleri.Attach(stokOzellikleri);
                this.ObjectContext.StokOzellikleri.DeleteObject(stokOzellikleri);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'StokReceteDetaylari' query.
        public IQueryable<StokReceteDetaylari> GetStokReceteDetaylari()
        {
            return this.ObjectContext.StokReceteDetaylari;
        }

        public void InsertStokReceteDetaylari(StokReceteDetaylari stokReceteDetaylari)
        {
            if ((stokReceteDetaylari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokReceteDetaylari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.StokReceteDetaylari.AddObject(stokReceteDetaylari);
            }
        }

        public void UpdateStokReceteDetaylari(StokReceteDetaylari currentStokReceteDetaylari)
        {
            this.ObjectContext.StokReceteDetaylari.AttachAsModified(currentStokReceteDetaylari, this.ChangeSet.GetOriginal(currentStokReceteDetaylari));
        }

        public void DeleteStokReceteDetaylari(StokReceteDetaylari stokReceteDetaylari)
        {
            if ((stokReceteDetaylari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokReceteDetaylari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.StokReceteDetaylari.Attach(stokReceteDetaylari);
                this.ObjectContext.StokReceteDetaylari.DeleteObject(stokReceteDetaylari);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'StokReceteTanimlari' query.
        public IQueryable<StokReceteTanimlari> GetStokReceteTanimlari()
        {
            return this.ObjectContext.StokReceteTanimlari;
        }

        public void InsertStokReceteTanimlari(StokReceteTanimlari stokReceteTanimlari)
        {
            if ((stokReceteTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokReceteTanimlari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.StokReceteTanimlari.AddObject(stokReceteTanimlari);
            }
        }

        public void UpdateStokReceteTanimlari(StokReceteTanimlari currentStokReceteTanimlari)
        {
            this.ObjectContext.StokReceteTanimlari.AttachAsModified(currentStokReceteTanimlari, this.ChangeSet.GetOriginal(currentStokReceteTanimlari));
        }

        public void DeleteStokReceteTanimlari(StokReceteTanimlari stokReceteTanimlari)
        {
            if ((stokReceteTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokReceteTanimlari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.StokReceteTanimlari.Attach(stokReceteTanimlari);
                this.ObjectContext.StokReceteTanimlari.DeleteObject(stokReceteTanimlari);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'StokSeriNoHareketleri' query.
        public IQueryable<StokSeriNoHareketleri> GetStokSeriNoHareketleri()
        {
            return this.ObjectContext.StokSeriNoHareketleri;
        }

        public void InsertStokSeriNoHareketleri(StokSeriNoHareketleri stokSeriNoHareketleri)
        {
            if ((stokSeriNoHareketleri.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokSeriNoHareketleri, EntityState.Added);
            }
            else
            {
                this.ObjectContext.StokSeriNoHareketleri.AddObject(stokSeriNoHareketleri);
            }
        }

        public void UpdateStokSeriNoHareketleri(StokSeriNoHareketleri currentStokSeriNoHareketleri)
        {
            this.ObjectContext.StokSeriNoHareketleri.AttachAsModified(currentStokSeriNoHareketleri, this.ChangeSet.GetOriginal(currentStokSeriNoHareketleri));
        }

        public void DeleteStokSeriNoHareketleri(StokSeriNoHareketleri stokSeriNoHareketleri)
        {
            if ((stokSeriNoHareketleri.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokSeriNoHareketleri, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.StokSeriNoHareketleri.Attach(stokSeriNoHareketleri);
                this.ObjectContext.StokSeriNoHareketleri.DeleteObject(stokSeriNoHareketleri);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'StokSeriNoTanimlari' query.
        public IQueryable<StokSeriNoTanimlari> GetStokSeriNoTanimlari()
        {
            return this.ObjectContext.StokSeriNoTanimlari;
        }

        public void InsertStokSeriNoTanimlari(StokSeriNoTanimlari stokSeriNoTanimlari)
        {
            if ((stokSeriNoTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokSeriNoTanimlari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.StokSeriNoTanimlari.AddObject(stokSeriNoTanimlari);
            }
        }

        public void UpdateStokSeriNoTanimlari(StokSeriNoTanimlari currentStokSeriNoTanimlari)
        {
            this.ObjectContext.StokSeriNoTanimlari.AttachAsModified(currentStokSeriNoTanimlari, this.ChangeSet.GetOriginal(currentStokSeriNoTanimlari));
        }

        public void DeleteStokSeriNoTanimlari(StokSeriNoTanimlari stokSeriNoTanimlari)
        {
            if ((stokSeriNoTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokSeriNoTanimlari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.StokSeriNoTanimlari.Attach(stokSeriNoTanimlari);
                this.ObjectContext.StokSeriNoTanimlari.DeleteObject(stokSeriNoTanimlari);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'StokTeminciTanimlari' query.
        public IQueryable<StokTeminciTanimlari> GetStokTeminciTanimlari()
        {
            return this.ObjectContext.StokTeminciTanimlari;
        }

        public void InsertStokTeminciTanimlari(StokTeminciTanimlari stokTeminciTanimlari)
        {
            if ((stokTeminciTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokTeminciTanimlari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.StokTeminciTanimlari.AddObject(stokTeminciTanimlari);
            }
        }

        public void UpdateStokTeminciTanimlari(StokTeminciTanimlari currentStokTeminciTanimlari)
        {
            this.ObjectContext.StokTeminciTanimlari.AttachAsModified(currentStokTeminciTanimlari, this.ChangeSet.GetOriginal(currentStokTeminciTanimlari));
        }

        public void DeleteStokTeminciTanimlari(StokTeminciTanimlari stokTeminciTanimlari)
        {
            if ((stokTeminciTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(stokTeminciTanimlari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.StokTeminciTanimlari.Attach(stokTeminciTanimlari);
                this.ObjectContext.StokTeminciTanimlari.DeleteObject(stokTeminciTanimlari);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'Subeler' query.
        public IQueryable<Subeler> GetSubeler()
        {
            return this.ObjectContext.Subeler;
        }

        public void InsertSubeler(Subeler subeler)
        {
            if ((subeler.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(subeler, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Subeler.AddObject(subeler);
            }
        }

        public void UpdateSubeler(Subeler currentSubeler)
        {
            this.ObjectContext.Subeler.AttachAsModified(currentSubeler, this.ChangeSet.GetOriginal(currentSubeler));
        }

        public void DeleteSubeler(Subeler subeler)
        {
            if ((subeler.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(subeler, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Subeler.Attach(subeler);
                this.ObjectContext.Subeler.DeleteObject(subeler);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'TeraziTanimlari' query.
        public IQueryable<TeraziTanimlari> GetTeraziTanimlari()
        {
            return this.ObjectContext.TeraziTanimlari;
        }

        public void InsertTeraziTanimlari(TeraziTanimlari teraziTanimlari)
        {
            if ((teraziTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(teraziTanimlari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.TeraziTanimlari.AddObject(teraziTanimlari);
            }
        }

        public void UpdateTeraziTanimlari(TeraziTanimlari currentTeraziTanimlari)
        {
            this.ObjectContext.TeraziTanimlari.AttachAsModified(currentTeraziTanimlari, this.ChangeSet.GetOriginal(currentTeraziTanimlari));
        }

        public void DeleteTeraziTanimlari(TeraziTanimlari teraziTanimlari)
        {
            if ((teraziTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(teraziTanimlari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.TeraziTanimlari.Attach(teraziTanimlari);
                this.ObjectContext.TeraziTanimlari.DeleteObject(teraziTanimlari);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'TevkifatTanimlari' query.
        public IQueryable<TevkifatTanimlari> GetTevkifatTanimlari()
        {
            return this.ObjectContext.TevkifatTanimlari;
        }

        public void InsertTevkifatTanimlari(TevkifatTanimlari tevkifatTanimlari)
        {
            if ((tevkifatTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(tevkifatTanimlari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.TevkifatTanimlari.AddObject(tevkifatTanimlari);
            }
        }

        public void UpdateTevkifatTanimlari(TevkifatTanimlari currentTevkifatTanimlari)
        {
            this.ObjectContext.TevkifatTanimlari.AttachAsModified(currentTevkifatTanimlari, this.ChangeSet.GetOriginal(currentTevkifatTanimlari));
        }

        public void DeleteTevkifatTanimlari(TevkifatTanimlari tevkifatTanimlari)
        {
            if ((tevkifatTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(tevkifatTanimlari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.TevkifatTanimlari.Attach(tevkifatTanimlari);
                this.ObjectContext.TevkifatTanimlari.DeleteObject(tevkifatTanimlari);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'VergiTanimlari' query.
        public IQueryable<VergiTanimlari> GetVergiTanimlari()
        {
            return this.ObjectContext.VergiTanimlari;
        }

        public void InsertVergiTanimlari(VergiTanimlari vergiTanimlari)
        {
            if ((vergiTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(vergiTanimlari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.VergiTanimlari.AddObject(vergiTanimlari);
            }
        }

        public void UpdateVergiTanimlari(VergiTanimlari currentVergiTanimlari)
        {
            this.ObjectContext.VergiTanimlari.AttachAsModified(currentVergiTanimlari, this.ChangeSet.GetOriginal(currentVergiTanimlari));
        }

        public void DeleteVergiTanimlari(VergiTanimlari vergiTanimlari)
        {
            if ((vergiTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(vergiTanimlari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.VergiTanimlari.Attach(vergiTanimlari);
                this.ObjectContext.VergiTanimlari.DeleteObject(vergiTanimlari);
            }
        }

        // TODO:
        // Consider constraining the results of your query method.  If you need additional input you can
        // add parameters to this method or create additional query methods with different names.
        // To support paging you will need to add ordering to the 'YazarkasaTanimlari' query.
        public IQueryable<YazarkasaTanimlari> GetYazarkasaTanimlari()
        {
            return this.ObjectContext.YazarkasaTanimlari;
        }

        public void InsertYazarkasaTanimlari(YazarkasaTanimlari yazarkasaTanimlari)
        {
            if ((yazarkasaTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(yazarkasaTanimlari, EntityState.Added);
            }
            else
            {
                this.ObjectContext.YazarkasaTanimlari.AddObject(yazarkasaTanimlari);
            }
        }

        public void UpdateYazarkasaTanimlari(YazarkasaTanimlari currentYazarkasaTanimlari)
        {
            this.ObjectContext.YazarkasaTanimlari.AttachAsModified(currentYazarkasaTanimlari, this.ChangeSet.GetOriginal(currentYazarkasaTanimlari));
        }

        public void DeleteYazarkasaTanimlari(YazarkasaTanimlari yazarkasaTanimlari)
        {
            if ((yazarkasaTanimlari.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(yazarkasaTanimlari, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.YazarkasaTanimlari.Attach(yazarkasaTanimlari);
                this.ObjectContext.YazarkasaTanimlari.DeleteObject(yazarkasaTanimlari);
            }
        }
    }
}


